home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 7 / Apprentice-Release7.iso / Source Code / C / Applications / Python 1.4 / Python 1.4 source / Mac / Modules / res / Resmodule.c < prev    next >
Encoding:
C/C++ Source or Header  |  1996-07-31  |  31.3 KB  |  1,393 lines  |  [TEXT/CWIE]
  1.  
  2. /* =========================== Module Res =========================== */
  3.  
  4. #include "Python.h"
  5.  
  6.  
  7.  
  8. #define SystemSevenOrLater 1
  9.  
  10. #include "macglue.h"
  11. #include <Memory.h>
  12. #include <Dialogs.h>
  13. #include <Menus.h>
  14. #include <Controls.h>
  15.  
  16. extern PyObject *ResObj_New(Handle);
  17. extern int ResObj_Convert(PyObject *, Handle *);
  18. extern PyObject *OptResObj_New(Handle);
  19. extern int OptResObj_Convert(PyObject *, Handle *);
  20.  
  21. extern PyObject *WinObj_New(WindowPtr);
  22. extern int WinObj_Convert(PyObject *, WindowPtr *);
  23. extern PyTypeObject Window_Type;
  24. #define WinObj_Check(x) ((x)->ob_type == &Window_Type)
  25.  
  26. extern PyObject *DlgObj_New(DialogPtr);
  27. extern int DlgObj_Convert(PyObject *, DialogPtr *);
  28. extern PyTypeObject Dialog_Type;
  29. #define DlgObj_Check(x) ((x)->ob_type == &Dialog_Type)
  30.  
  31. extern PyObject *MenuObj_New(MenuHandle);
  32. extern int MenuObj_Convert(PyObject *, MenuHandle *);
  33.  
  34. extern PyObject *CtlObj_New(ControlHandle);
  35. extern int CtlObj_Convert(PyObject *, ControlHandle *);
  36.  
  37. extern PyObject *GrafObj_New(GrafPtr);
  38. extern int GrafObj_Convert(PyObject *, GrafPtr *);
  39.  
  40. extern PyObject *BMObj_New(BitMapPtr);
  41. extern int BMObj_Convert(PyObject *, BitMapPtr *);
  42.  
  43. extern PyObject *WinObj_WhichWindow(WindowPtr);
  44.  
  45. #include <Resources.h>
  46.  
  47. #define resNotFound -192 /* Can't include <Errors.h> because of Python's "errors.h" */
  48.  
  49. static PyObject *Res_Error;
  50.  
  51. /* ---------------------- Object type Resource ---------------------- */
  52.  
  53. PyTypeObject Resource_Type;
  54.  
  55. #define ResObj_Check(x) ((x)->ob_type == &Resource_Type)
  56.  
  57. typedef struct ResourceObject {
  58.     PyObject_HEAD
  59.     Handle ob_itself;
  60. } ResourceObject;
  61.  
  62. PyObject *ResObj_New(itself)
  63.     Handle itself;
  64. {
  65.     ResourceObject *it;
  66.     if (itself == NULL) return PyMac_Error(resNotFound);
  67.     it = PyObject_NEW(ResourceObject, &Resource_Type);
  68.     if (it == NULL) return NULL;
  69.     it->ob_itself = itself;
  70.     return (PyObject *)it;
  71. }
  72. ResObj_Convert(v, p_itself)
  73.     PyObject *v;
  74.     Handle *p_itself;
  75. {
  76.     if (!ResObj_Check(v))
  77.     {
  78.         PyErr_SetString(PyExc_TypeError, "Resource required");
  79.         return 0;
  80.     }
  81.     *p_itself = ((ResourceObject *)v)->ob_itself;
  82.     return 1;
  83. }
  84.  
  85. static void ResObj_dealloc(self)
  86.     ResourceObject *self;
  87. {
  88.     /* Cleanup of self->ob_itself goes here */
  89.     PyMem_DEL(self);
  90. }
  91.  
  92. static PyObject *ResObj_HomeResFile(_self, _args)
  93.     ResourceObject *_self;
  94.     PyObject *_args;
  95. {
  96.     PyObject *_res = NULL;
  97.     short _rv;
  98.     if (!PyArg_ParseTuple(_args, ""))
  99.         return NULL;
  100.     _rv = HomeResFile(_self->ob_itself);
  101.     {
  102.         OSErr _err = ResError();
  103.         if (_err != noErr) return PyMac_Error(_err);
  104.     }
  105.     _res = Py_BuildValue("h",
  106.                          _rv);
  107.     return _res;
  108. }
  109.  
  110. static PyObject *ResObj_LoadResource(_self, _args)
  111.     ResourceObject *_self;
  112.     PyObject *_args;
  113. {
  114.     PyObject *_res = NULL;
  115.     if (!PyArg_ParseTuple(_args, ""))
  116.         return NULL;
  117.     LoadResource(_self->ob_itself);
  118.     {
  119.         OSErr _err = ResError();
  120.         if (_err != noErr) return PyMac_Error(_err);
  121.     }
  122.     Py_INCREF(Py_None);
  123.     _res = Py_None;
  124.     return _res;
  125. }
  126.  
  127. static PyObject *ResObj_ReleaseResource(_self, _args)
  128.     ResourceObject *_self;
  129.     PyObject *_args;
  130. {
  131.     PyObject *_res = NULL;
  132.     if (!PyArg_ParseTuple(_args, ""))
  133.         return NULL;
  134.     ReleaseResource(_self->ob_itself);
  135.     {
  136.         OSErr _err = ResError();
  137.         if (_err != noErr) return PyMac_Error(_err);
  138.     }
  139.     Py_INCREF(Py_None);
  140.     _res = Py_None;
  141.     return _res;
  142. }
  143.  
  144. static PyObject *ResObj_DetachResource(_self, _args)
  145.     ResourceObject *_self;
  146.     PyObject *_args;
  147. {
  148.     PyObject *_res = NULL;
  149.     if (!PyArg_ParseTuple(_args, ""))
  150.         return NULL;
  151.     DetachResource(_self->ob_itself);
  152.     {
  153.         OSErr _err = ResError();
  154.         if (_err != noErr) return PyMac_Error(_err);
  155.     }
  156.     Py_INCREF(Py_None);
  157.     _res = Py_None;
  158.     return _res;
  159. }
  160.  
  161. static PyObject *ResObj_GetResAttrs(_self, _args)
  162.     ResourceObject *_self;
  163.     PyObject *_args;
  164. {
  165.     PyObject *_res = NULL;
  166.     short _rv;
  167.     if (!PyArg_ParseTuple(_args, ""))
  168.         return NULL;
  169.     _rv = GetResAttrs(_self->ob_itself);
  170.     {
  171.         OSErr _err = ResError();
  172.         if (_err != noErr) return PyMac_Error(_err);
  173.     }
  174.     _res = Py_BuildValue("h",
  175.                          _rv);
  176.     return _res;
  177. }
  178.  
  179. static PyObject *ResObj_GetResInfo(_self, _args)
  180.     ResourceObject *_self;
  181.     PyObject *_args;
  182. {
  183.     PyObject *_res = NULL;
  184.     short theID;
  185.     ResType theType;
  186.     Str255 name;
  187.     if (!PyArg_ParseTuple(_args, ""))
  188.         return NULL;
  189.     GetResInfo(_self->ob_itself,
  190.                &theID,
  191.                &theType,
  192.                name);
  193.     {
  194.         OSErr _err = ResError();
  195.         if (_err != noErr) return PyMac_Error(_err);
  196.     }
  197.     _res = Py_BuildValue("hO&O&",
  198.                          theID,
  199.                          PyMac_BuildOSType, theType,
  200.                          PyMac_BuildStr255, name);
  201.     return _res;
  202. }
  203.  
  204. static PyObject *ResObj_SetResInfo(_self, _args)
  205.     ResourceObject *_self;
  206.     PyObject *_args;
  207. {
  208.     PyObject *_res = NULL;
  209.     short theID;
  210.     Str255 name;
  211.     if (!PyArg_ParseTuple(_args, "hO&",
  212.                           &theID,
  213.                           PyMac_GetStr255, name))
  214.         return NULL;
  215.     SetResInfo(_self->ob_itself,
  216.                theID,
  217.                name);
  218.     {
  219.         OSErr _err = ResError();
  220.         if (_err != noErr) return PyMac_Error(_err);
  221.     }
  222.     Py_INCREF(Py_None);
  223.     _res = Py_None;
  224.     return _res;
  225. }
  226.  
  227. static PyObject *ResObj_AddResource(_self, _args)
  228.     ResourceObject *_self;
  229.     PyObject *_args;
  230. {
  231.     PyObject *_res = NULL;
  232.     ResType theType;
  233.     short theID;
  234.     Str255 name;
  235.     if (!PyArg_ParseTuple(_args, "O&hO&",
  236.                           PyMac_GetOSType, &theType,
  237.                           &theID,
  238.                           PyMac_GetStr255, name))
  239.         return NULL;
  240.     AddResource(_self->ob_itself,
  241.                 theType,
  242.                 theID,
  243.                 name);
  244.     {
  245.         OSErr _err = ResError();
  246.         if (_err != noErr) return PyMac_Error(_err);
  247.     }
  248.     Py_INCREF(Py_None);
  249.     _res = Py_None;
  250.     return _res;
  251. }
  252.  
  253. static PyObject *ResObj_GetResourceSizeOnDisk(_self, _args)
  254.     ResourceObject *_self;
  255.     PyObject *_args;
  256. {
  257.     PyObject *_res = NULL;
  258.     long _rv;
  259.     if (!PyArg_ParseTuple(_args, ""))
  260.         return NULL;
  261.     _rv = GetResourceSizeOnDisk(_self->ob_itself);
  262.     {
  263.         OSErr _err = ResError();
  264.         if (_err != noErr) return PyMac_Error(_err);
  265.     }
  266.     _res = Py_BuildValue("l",
  267.                          _rv);
  268.     return _res;
  269. }
  270.  
  271. static PyObject *ResObj_GetMaxResourceSize(_self, _args)
  272.     ResourceObject *_self;
  273.     PyObject *_args;
  274. {
  275.     PyObject *_res = NULL;
  276.     long _rv;
  277.     if (!PyArg_ParseTuple(_args, ""))
  278.         return NULL;
  279.     _rv = GetMaxResourceSize(_self->ob_itself);
  280.     {
  281.         OSErr _err = ResError();
  282.         if (_err != noErr) return PyMac_Error(_err);
  283.     }
  284.     _res = Py_BuildValue("l",
  285.                          _rv);
  286.     return _res;
  287. }
  288.  
  289. static PyObject *ResObj_RsrcMapEntry(_self, _args)
  290.     ResourceObject *_self;
  291.     PyObject *_args;
  292. {
  293.     PyObject *_res = NULL;
  294.     long _rv;
  295.     if (!PyArg_ParseTuple(_args, ""))
  296.         return NULL;
  297.     _rv = RsrcMapEntry(_self->ob_itself);
  298.     {
  299.         OSErr _err = ResError();
  300.         if (_err != noErr) return PyMac_Error(_err);
  301.     }
  302.     _res = Py_BuildValue("l",
  303.                          _rv);
  304.     return _res;
  305. }
  306.  
  307. static PyObject *ResObj_SetResAttrs(_self, _args)
  308.     ResourceObject *_self;
  309.     PyObject *_args;
  310. {
  311.     PyObject *_res = NULL;
  312.     short attrs;
  313.     if (!PyArg_ParseTuple(_args, "h",
  314.                           &attrs))
  315.         return NULL;
  316.     SetResAttrs(_self->ob_itself,
  317.                 attrs);
  318.     {
  319.         OSErr _err = ResError();
  320.         if (_err != noErr) return PyMac_Error(_err);
  321.     }
  322.     Py_INCREF(Py_None);
  323.     _res = Py_None;
  324.     return _res;
  325. }
  326.  
  327. static PyObject *ResObj_ChangedResource(_self, _args)
  328.     ResourceObject *_self;
  329.     PyObject *_args;
  330. {
  331.     PyObject *_res = NULL;
  332.     if (!PyArg_ParseTuple(_args, ""))
  333.         return NULL;
  334.     ChangedResource(_self->ob_itself);
  335.     {
  336.         OSErr _err = ResError();
  337.         if (_err != noErr) return PyMac_Error(_err);
  338.     }
  339.     Py_INCREF(Py_None);
  340.     _res = Py_None;
  341.     return _res;
  342. }
  343.  
  344. static PyObject *ResObj_RemoveResource(_self, _args)
  345.     ResourceObject *_self;
  346.     PyObject *_args;
  347. {
  348.     PyObject *_res = NULL;
  349.     if (!PyArg_ParseTuple(_args, ""))
  350.         return NULL;
  351.     RemoveResource(_self->ob_itself);
  352.     {
  353.         OSErr _err = ResError();
  354.         if (_err != noErr) return PyMac_Error(_err);
  355.     }
  356.     Py_INCREF(Py_None);
  357.     _res = Py_None;
  358.     return _res;
  359. }
  360.  
  361. static PyObject *ResObj_WriteResource(_self, _args)
  362.     ResourceObject *_self;
  363.     PyObject *_args;
  364. {
  365.     PyObject *_res = NULL;
  366.     if (!PyArg_ParseTuple(_args, ""))
  367.         return NULL;
  368.     WriteResource(_self->ob_itself);
  369.     {
  370.         OSErr _err = ResError();
  371.         if (_err != noErr) return PyMac_Error(_err);
  372.     }
  373.     Py_INCREF(Py_None);
  374.     _res = Py_None;
  375.     return _res;
  376. }
  377.  
  378. static PyObject *ResObj_SetResourceSize(_self, _args)
  379.     ResourceObject *_self;
  380.     PyObject *_args;
  381. {
  382.     PyObject *_res = NULL;
  383.     long newSize;
  384.     if (!PyArg_ParseTuple(_args, "l",
  385.                           &newSize))
  386.         return NULL;
  387.     SetResourceSize(_self->ob_itself,
  388.                     newSize);
  389.     {
  390.         OSErr _err = ResError();
  391.         if (_err != noErr) return PyMac_Error(_err);
  392.     }
  393.     Py_INCREF(Py_None);
  394.     _res = Py_None;
  395.     return _res;
  396. }
  397.  
  398. static PyObject *ResObj_GetNextFOND(_self, _args)
  399.     ResourceObject *_self;
  400.     PyObject *_args;
  401. {
  402.     PyObject *_res = NULL;
  403.     Handle _rv;
  404.     if (!PyArg_ParseTuple(_args, ""))
  405.         return NULL;
  406.     _rv = GetNextFOND(_self->ob_itself);
  407.     {
  408.         OSErr _err = ResError();
  409.         if (_err != noErr) return PyMac_Error(_err);
  410.     }
  411.     _res = Py_BuildValue("O&",
  412.                          ResObj_New, _rv);
  413.     return _res;
  414. }
  415.  
  416. static PyObject *ResObj_as_Control(_self, _args)
  417.     ResourceObject *_self;
  418.     PyObject *_args;
  419. {
  420.     PyObject *_res = NULL;
  421.  
  422.     return CtlObj_New((ControlHandle)_self->ob_itself);
  423.  
  424. }
  425.  
  426. static PyObject *ResObj_as_Menu(_self, _args)
  427.     ResourceObject *_self;
  428.     PyObject *_args;
  429. {
  430.     PyObject *_res = NULL;
  431.  
  432.     return MenuObj_New((MenuHandle)_self->ob_itself);
  433.  
  434. }
  435.  
  436. static PyMethodDef ResObj_methods[] = {
  437.     {"HomeResFile", (PyCFunction)ResObj_HomeResFile, 1,
  438.      "() -> (short _rv)"},
  439.     {"LoadResource", (PyCFunction)ResObj_LoadResource, 1,
  440.      "() -> None"},
  441.     {"ReleaseResource", (PyCFunction)ResObj_ReleaseResource, 1,
  442.      "() -> None"},
  443.     {"DetachResource", (PyCFunction)ResObj_DetachResource, 1,
  444.      "() -> None"},
  445.     {"GetResAttrs", (PyCFunction)ResObj_GetResAttrs, 1,
  446.      "() -> (short _rv)"},
  447.     {"GetResInfo", (PyCFunction)ResObj_GetResInfo, 1,
  448.      "() -> (short theID, ResType theType, Str255 name)"},
  449.     {"SetResInfo", (PyCFunction)ResObj_SetResInfo, 1,
  450.      "(short theID, Str255 name) -> None"},
  451.     {"AddResource", (PyCFunction)ResObj_AddResource, 1,
  452.      "(ResType theType, short theID, Str255 name) -> None"},
  453.     {"GetResourceSizeOnDisk", (PyCFunction)ResObj_GetResourceSizeOnDisk, 1,
  454.      "() -> (long _rv)"},
  455.     {"GetMaxResourceSize", (PyCFunction)ResObj_GetMaxResourceSize, 1,
  456.      "() -> (long _rv)"},
  457.     {"RsrcMapEntry", (PyCFunction)ResObj_RsrcMapEntry, 1,
  458.      "() -> (long _rv)"},
  459.     {"SetResAttrs", (PyCFunction)ResObj_SetResAttrs, 1,
  460.      "(short attrs) -> None"},
  461.     {"ChangedResource", (PyCFunction)ResObj_ChangedResource, 1,
  462.      "() -> None"},
  463.     {"RemoveResource", (PyCFunction)ResObj_RemoveResource, 1,
  464.      "() -> None"},
  465.     {"WriteResource", (PyCFunction)ResObj_WriteResource, 1,
  466.      "() -> None"},
  467.     {"SetResourceSize", (PyCFunction)ResObj_SetResourceSize, 1,
  468.      "(long newSize) -> None"},
  469.     {"GetNextFOND", (PyCFunction)ResObj_GetNextFOND, 1,
  470.      "() -> (Handle _rv)"},
  471.     {"as_Control", (PyCFunction)ResObj_as_Control, 1,
  472.      "Return this resource/handle as a Control"},
  473.     {"as_Menu", (PyCFunction)ResObj_as_Menu, 1,
  474.      "Return this resource/handle as a Menu"},
  475.     {NULL, NULL, 0}
  476. };
  477.  
  478. PyMethodChain ResObj_chain = { ResObj_methods, NULL };
  479.  
  480. static PyObject *ResObj_getattr(self, name)
  481.     ResourceObject *self;
  482.     char *name;
  483. {
  484.  
  485.     if (strcmp(name, "size") == 0)
  486.         return PyInt_FromLong(GetHandleSize(self->ob_itself));
  487.     if (strcmp(name, "data") == 0) {
  488.         PyObject *res;
  489.         char state;
  490.         state = HGetState(self->ob_itself);
  491.         HLock(self->ob_itself);
  492.         res = PyString_FromStringAndSize(
  493.             *self->ob_itself,
  494.             GetHandleSize(self->ob_itself));
  495.         HUnlock(self->ob_itself);
  496.         HSetState(self->ob_itself, state);
  497.         return res;
  498.     }
  499.     if (strcmp(name, "__members__") == 0)
  500.         return Py_BuildValue("[ss]", "data", "size");
  501.  
  502.     return Py_FindMethodInChain(&ResObj_chain, (PyObject *)self, name);
  503. }
  504.  
  505. static int
  506. ResObj_setattr(self, name, value)
  507.     ResourceObject *self;
  508.     char *name;
  509.     PyObject *value;
  510. {
  511.     char *data;
  512.     long size;
  513.     
  514.     if (strcmp(name, "data") != 0 || value == NULL )
  515.         return -1;
  516.     if ( !PyString_Check(value) )
  517.         return -1;
  518.     size = PyString_Size(value);
  519.     data = PyString_AsString(value);
  520.     /* XXXX Do I need the GetState/SetState calls? */
  521.     SetHandleSize(self->ob_itself, size);
  522.     if ( MemError())
  523.         return -1;
  524.     HLock(self->ob_itself);
  525.     memcpy((char *)*self->ob_itself, data, size);
  526.     HUnlock(self->ob_itself);
  527.     /* XXXX Should I do the Changed call immedeately? */
  528.     return 0;
  529. }
  530.  
  531.  
  532. PyTypeObject Resource_Type = {
  533.     PyObject_HEAD_INIT(&PyType_Type)
  534.     0, /*ob_size*/
  535.     "Resource", /*tp_name*/
  536.     sizeof(ResourceObject), /*tp_basicsize*/
  537.     0, /*tp_itemsize*/
  538.     /* methods */
  539.     (destructor) ResObj_dealloc, /*tp_dealloc*/
  540.     0, /*tp_print*/
  541.     (getattrfunc) ResObj_getattr, /*tp_getattr*/
  542.     (setattrfunc) ResObj_setattr, /*tp_setattr*/
  543. };
  544.  
  545. /* -------------------- End object type Resource -------------------- */
  546.  
  547.  
  548. static PyObject *Res_InitResources(_self, _args)
  549.     PyObject *_self;
  550.     PyObject *_args;
  551. {
  552.     PyObject *_res = NULL;
  553.     short _rv;
  554.     if (!PyArg_ParseTuple(_args, ""))
  555.         return NULL;
  556.     _rv = InitResources();
  557.     {
  558.         OSErr _err = ResError();
  559.         if (_err != noErr) return PyMac_Error(_err);
  560.     }
  561.     _res = Py_BuildValue("h",
  562.                          _rv);
  563.     return _res;
  564. }
  565.  
  566. static PyObject *Res_RsrcZoneInit(_self, _args)
  567.     PyObject *_self;
  568.     PyObject *_args;
  569. {
  570.     PyObject *_res = NULL;
  571.     if (!PyArg_ParseTuple(_args, ""))
  572.         return NULL;
  573.     RsrcZoneInit();
  574.     {
  575.         OSErr _err = ResError();
  576.         if (_err != noErr) return PyMac_Error(_err);
  577.     }
  578.     Py_INCREF(Py_None);
  579.     _res = Py_None;
  580.     return _res;
  581. }
  582.  
  583. static PyObject *Res_CloseResFile(_self, _args)
  584.     PyObject *_self;
  585.     PyObject *_args;
  586. {
  587.     PyObject *_res = NULL;
  588.     short refNum;
  589.     if (!PyArg_ParseTuple(_args, "h",
  590.                           &refNum))
  591.         return NULL;
  592.     CloseResFile(refNum);
  593.     {
  594.         OSErr _err = ResError();
  595.         if (_err != noErr) return PyMac_Error(_err);
  596.     }
  597.     Py_INCREF(Py_None);
  598.     _res = Py_None;
  599.     return _res;
  600. }
  601.  
  602. static PyObject *Res_ResError(_self, _args)
  603.     PyObject *_self;
  604.     PyObject *_args;
  605. {
  606.     PyObject *_res = NULL;
  607.     short _rv;
  608.     if (!PyArg_ParseTuple(_args, ""))
  609.         return NULL;
  610.     _rv = ResError();
  611.     {
  612.         OSErr _err = ResError();
  613.         if (_err != noErr) return PyMac_Error(_err);
  614.     }
  615.     _res = Py_BuildValue("h",
  616.                          _rv);
  617.     return _res;
  618. }
  619.  
  620. static PyObject *Res_CurResFile(_self, _args)
  621.     PyObject *_self;
  622.     PyObject *_args;
  623. {
  624.     PyObject *_res = NULL;
  625.     short _rv;
  626.     if (!PyArg_ParseTuple(_args, ""))
  627.         return NULL;
  628.     _rv = CurResFile();
  629.     {
  630.         OSErr _err = ResError();
  631.         if (_err != noErr) return PyMac_Error(_err);
  632.     }
  633.     _res = Py_BuildValue("h",
  634.                          _rv);
  635.     return _res;
  636. }
  637.  
  638. static PyObject *Res_CreateResFile(_self, _args)
  639.     PyObject *_self;
  640.     PyObject *_args;
  641. {
  642.     PyObject *_res = NULL;
  643.     Str255 fileName;
  644.     if (!PyArg_ParseTuple(_args, "O&",
  645.                           PyMac_GetStr255, fileName))
  646.         return NULL;
  647.     CreateResFile(fileName);
  648.     {
  649.         OSErr _err = ResError();
  650.         if (_err != noErr) return PyMac_Error(_err);
  651.     }
  652.     Py_INCREF(Py_None);
  653.     _res = Py_None;
  654.     return _res;
  655. }
  656.  
  657. static PyObject *Res_OpenResFile(_self, _args)
  658.     PyObject *_self;
  659.     PyObject *_args;
  660. {
  661.     PyObject *_res = NULL;
  662.     short _rv;
  663.     Str255 fileName;
  664.     if (!PyArg_ParseTuple(_args, "O&",
  665.                           PyMac_GetStr255, fileName))
  666.         return NULL;
  667.     _rv = OpenResFile(fileName);
  668.     {
  669.         OSErr _err = ResError();
  670.         if (_err != noErr) return PyMac_Error(_err);
  671.     }
  672.     _res = Py_BuildValue("h",
  673.                          _rv);
  674.     return _res;
  675. }
  676.  
  677. static PyObject *Res_UseResFile(_self, _args)
  678.     PyObject *_self;
  679.     PyObject *_args;
  680. {
  681.     PyObject *_res = NULL;
  682.     short refNum;
  683.     if (!PyArg_ParseTuple(_args, "h",
  684.                           &refNum))
  685.         return NULL;
  686.     UseResFile(refNum);
  687.     {
  688.         OSErr _err = ResError();
  689.         if (_err != noErr) return PyMac_Error(_err);
  690.     }
  691.     Py_INCREF(Py_None);
  692.     _res = Py_None;
  693.     return _res;
  694. }
  695.  
  696. static PyObject *Res_CountTypes(_self, _args)
  697.     PyObject *_self;
  698.     PyObject *_args;
  699. {
  700.     PyObject *_res = NULL;
  701.     short _rv;
  702.     if (!PyArg_ParseTuple(_args, ""))
  703.         return NULL;
  704.     _rv = CountTypes();
  705.     {
  706.         OSErr _err = ResError();
  707.         if (_err != noErr) return PyMac_Error(_err);
  708.     }
  709.     _res = Py_BuildValue("h",
  710.                          _rv);
  711.     return _res;
  712. }
  713.  
  714. static PyObject *Res_Count1Types(_self, _args)
  715.     PyObject *_self;
  716.     PyObject *_args;
  717. {
  718.     PyObject *_res = NULL;
  719.     short _rv;
  720.     if (!PyArg_ParseTuple(_args, ""))
  721.         return NULL;
  722.     _rv = Count1Types();
  723.     {
  724.         OSErr _err = ResError();
  725.         if (_err != noErr) return PyMac_Error(_err);
  726.     }
  727.     _res = Py_BuildValue("h",
  728.                          _rv);
  729.     return _res;
  730. }
  731.  
  732. static PyObject *Res_GetIndType(_self, _args)
  733.     PyObject *_self;
  734.     PyObject *_args;
  735. {
  736.     PyObject *_res = NULL;
  737.     ResType theType;
  738.     short index;
  739.     if (!PyArg_ParseTuple(_args, "h",
  740.                           &index))
  741.         return NULL;
  742.     GetIndType(&theType,
  743.                index);
  744.     {
  745.         OSErr _err = ResError();
  746.         if (_err != noErr) return PyMac_Error(_err);
  747.     }
  748.     _res = Py_BuildValue("O&",
  749.                          PyMac_BuildOSType, theType);
  750.     return _res;
  751. }
  752.  
  753. static PyObject *Res_Get1IndType(_self, _args)
  754.     PyObject *_self;
  755.     PyObject *_args;
  756. {
  757.     PyObject *_res = NULL;
  758.     ResType theType;
  759.     short index;
  760.     if (!PyArg_ParseTuple(_args, "h",
  761.                           &index))
  762.         return NULL;
  763.     Get1IndType(&theType,
  764.                 index);
  765.     {
  766.         OSErr _err = ResError();
  767.         if (_err != noErr) return PyMac_Error(_err);
  768.     }
  769.     _res = Py_BuildValue("O&",
  770.                          PyMac_BuildOSType, theType);
  771.     return _res;
  772. }
  773.  
  774. static PyObject *Res_SetResLoad(_self, _args)
  775.     PyObject *_self;
  776.     PyObject *_args;
  777. {
  778.     PyObject *_res = NULL;
  779.     Boolean load;
  780.     if (!PyArg_ParseTuple(_args, "b",
  781.                           &load))
  782.         return NULL;
  783.     SetResLoad(load);
  784.     {
  785.         OSErr _err = ResError();
  786.         if (_err != noErr) return PyMac_Error(_err);
  787.     }
  788.     Py_INCREF(Py_None);
  789.     _res = Py_None;
  790.     return _res;
  791. }
  792.  
  793. static PyObject *Res_CountResources(_self, _args)
  794.     PyObject *_self;
  795.     PyObject *_args;
  796. {
  797.     PyObject *_res = NULL;
  798.     short _rv;
  799.     ResType theType;
  800.     if (!PyArg_ParseTuple(_args, "O&",
  801.                           PyMac_GetOSType, &theType))
  802.         return NULL;
  803.     _rv = CountResources(theType);
  804.     {
  805.         OSErr _err = ResError();
  806.         if (_err != noErr) return PyMac_Error(_err);
  807.     }
  808.     _res = Py_BuildValue("h",
  809.                          _rv);
  810.     return _res;
  811. }
  812.  
  813. static PyObject *Res_Count1Resources(_self, _args)
  814.     PyObject *_self;
  815.     PyObject *_args;
  816. {
  817.     PyObject *_res = NULL;
  818.     short _rv;
  819.     ResType theType;
  820.     if (!PyArg_ParseTuple(_args, "O&",
  821.                           PyMac_GetOSType, &theType))
  822.         return NULL;
  823.     _rv = Count1Resources(theType);
  824.     {
  825.         OSErr _err = ResError();
  826.         if (_err != noErr) return PyMac_Error(_err);
  827.     }
  828.     _res = Py_BuildValue("h",
  829.                          _rv);
  830.     return _res;
  831. }
  832.  
  833. static PyObject *Res_GetIndResource(_self, _args)
  834.     PyObject *_self;
  835.     PyObject *_args;
  836. {
  837.     PyObject *_res = NULL;
  838.     Handle _rv;
  839.     ResType theType;
  840.     short index;
  841.     if (!PyArg_ParseTuple(_args, "O&h",
  842.                           PyMac_GetOSType, &theType,
  843.                           &index))
  844.         return NULL;
  845.     _rv = GetIndResource(theType,
  846.                          index);
  847.     {
  848.         OSErr _err = ResError();
  849.         if (_err != noErr) return PyMac_Error(_err);
  850.     }
  851.     _res = Py_BuildValue("O&",
  852.                          ResObj_New, _rv);
  853.     return _res;
  854. }
  855.  
  856. static PyObject *Res_Get1IndResource(_self, _args)
  857.     PyObject *_self;
  858.     PyObject *_args;
  859. {
  860.     PyObject *_res = NULL;
  861.     Handle _rv;
  862.     ResType theType;
  863.     short index;
  864.     if (!PyArg_ParseTuple(_args, "O&h",
  865.                           PyMac_GetOSType, &theType,
  866.                           &index))
  867.         return NULL;
  868.     _rv = Get1IndResource(theType,
  869.                           index);
  870.     {
  871.         OSErr _err = ResError();
  872.         if (_err != noErr) return PyMac_Error(_err);
  873.     }
  874.     _res = Py_BuildValue("O&",
  875.                          ResObj_New, _rv);
  876.     return _res;
  877. }
  878.  
  879. static PyObject *Res_GetResource(_self, _args)
  880.     PyObject *_self;
  881.     PyObject *_args;
  882. {
  883.     PyObject *_res = NULL;
  884.     Handle _rv;
  885.     ResType theType;
  886.     short theID;
  887.     if (!PyArg_ParseTuple(_args, "O&h",
  888.                           PyMac_GetOSType, &theType,
  889.                           &theID))
  890.         return NULL;
  891.     _rv = GetResource(theType,
  892.                       theID);
  893.     {
  894.         OSErr _err = ResError();
  895.         if (_err != noErr) return PyMac_Error(_err);
  896.     }
  897.     _res = Py_BuildValue("O&",
  898.                          ResObj_New, _rv);
  899.     return _res;
  900. }
  901.  
  902. static PyObject *Res_Get1Resource(_self, _args)
  903.     PyObject *_self;
  904.     PyObject *_args;
  905. {
  906.     PyObject *_res = NULL;
  907.     Handle _rv;
  908.     ResType theType;
  909.     short theID;
  910.     if (!PyArg_ParseTuple(_args, "O&h",
  911.                           PyMac_GetOSType, &theType,
  912.                           &theID))
  913.         return NULL;
  914.     _rv = Get1Resource(theType,
  915.                        theID);
  916.     {
  917.         OSErr _err = ResError();
  918.         if (_err != noErr) return PyMac_Error(_err);
  919.     }
  920.     _res = Py_BuildValue("O&",
  921.                          ResObj_New, _rv);
  922.     return _res;
  923. }
  924.  
  925. static PyObject *Res_GetNamedResource(_self, _args)
  926.     PyObject *_self;
  927.     PyObject *_args;
  928. {
  929.     PyObject *_res = NULL;
  930.     Handle _rv;
  931.     ResType theType;
  932.     Str255 name;
  933.     if (!PyArg_ParseTuple(_args, "O&O&",
  934.                           PyMac_GetOSType, &theType,
  935.                           PyMac_GetStr255, name))
  936.         return NULL;
  937.     _rv = GetNamedResource(theType,
  938.                            name);
  939.     {
  940.         OSErr _err = ResError();
  941.         if (_err != noErr) return PyMac_Error(_err);
  942.     }
  943.     _res = Py_BuildValue("O&",
  944.                          ResObj_New, _rv);
  945.     return _res;
  946. }
  947.  
  948. static PyObject *Res_Get1NamedResource(_self, _args)
  949.     PyObject *_self;
  950.     PyObject *_args;
  951. {
  952.     PyObject *_res = NULL;
  953.     Handle _rv;
  954.     ResType theType;
  955.     Str255 name;
  956.     if (!PyArg_ParseTuple(_args, "O&O&",
  957.                           PyMac_GetOSType, &theType,
  958.                           PyMac_GetStr255, name))
  959.         return NULL;
  960.     _rv = Get1NamedResource(theType,
  961.                             name);
  962.     {
  963.         OSErr _err = ResError();
  964.         if (_err != noErr) return PyMac_Error(_err);
  965.     }
  966.     _res = Py_BuildValue("O&",
  967.                          ResObj_New, _rv);
  968.     return _res;
  969. }
  970.  
  971. static PyObject *Res_UniqueID(_self, _args)
  972.     PyObject *_self;
  973.     PyObject *_args;
  974. {
  975.     PyObject *_res = NULL;
  976.     short _rv;
  977.     ResType theType;
  978.     if (!PyArg_ParseTuple(_args, "O&",
  979.                           PyMac_GetOSType, &theType))
  980.         return NULL;
  981.     _rv = UniqueID(theType);
  982.     {
  983.         OSErr _err = ResError();
  984.         if (_err != noErr) return PyMac_Error(_err);
  985.     }
  986.     _res = Py_BuildValue("h",
  987.                          _rv);
  988.     return _res;
  989. }
  990.  
  991. static PyObject *Res_Unique1ID(_self, _args)
  992.     PyObject *_self;
  993.     PyObject *_args;
  994. {
  995.     PyObject *_res = NULL;
  996.     short _rv;
  997.     ResType theType;
  998.     if (!PyArg_ParseTuple(_args, "O&",
  999.                           PyMac_GetOSType, &theType))
  1000.         return NULL;
  1001.     _rv = Unique1ID(theType);
  1002.     {
  1003.         OSErr _err = ResError();
  1004.         if (_err != noErr) return PyMac_Error(_err);
  1005.     }
  1006.     _res = Py_BuildValue("h",
  1007.                          _rv);
  1008.     return _res;
  1009. }
  1010.  
  1011. static PyObject *Res_UpdateResFile(_self, _args)
  1012.     PyObject *_self;
  1013.     PyObject *_args;
  1014. {
  1015.     PyObject *_res = NULL;
  1016.     short refNum;
  1017.     if (!PyArg_ParseTuple(_args, "h",
  1018.                           &refNum))
  1019.         return NULL;
  1020.     UpdateResFile(refNum);
  1021.     {
  1022.         OSErr _err = ResError();
  1023.         if (_err != noErr) return PyMac_Error(_err);
  1024.     }
  1025.     Py_INCREF(Py_None);
  1026.     _res = Py_None;
  1027.     return _res;
  1028. }
  1029.  
  1030. static PyObject *Res_SetResPurge(_self, _args)
  1031.     PyObject *_self;
  1032.     PyObject *_args;
  1033. {
  1034.     PyObject *_res = NULL;
  1035.     Boolean install;
  1036.     if (!PyArg_ParseTuple(_args, "b",
  1037.                           &install))
  1038.         return NULL;
  1039.     SetResPurge(install);
  1040.     {
  1041.         OSErr _err = ResError();
  1042.         if (_err != noErr) return PyMac_Error(_err);
  1043.     }
  1044.     Py_INCREF(Py_None);
  1045.     _res = Py_None;
  1046.     return _res;
  1047. }
  1048.  
  1049. static PyObject *Res_GetResFileAttrs(_self, _args)
  1050.     PyObject *_self;
  1051.     PyObject *_args;
  1052. {
  1053.     PyObject *_res = NULL;
  1054.     short _rv;
  1055.     short refNum;
  1056.     if (!PyArg_ParseTuple(_args, "h",
  1057.                           &refNum))
  1058.         return NULL;
  1059.     _rv = GetResFileAttrs(refNum);
  1060.     {
  1061.         OSErr _err = ResError();
  1062.         if (_err != noErr) return PyMac_Error(_err);
  1063.     }
  1064.     _res = Py_BuildValue("h",
  1065.                          _rv);
  1066.     return _res;
  1067. }
  1068.  
  1069. static PyObject *Res_SetResFileAttrs(_self, _args)
  1070.     PyObject *_self;
  1071.     PyObject *_args;
  1072. {
  1073.     PyObject *_res = NULL;
  1074.     short refNum;
  1075.     short attrs;
  1076.     if (!PyArg_ParseTuple(_args, "hh",
  1077.                           &refNum,
  1078.                           &attrs))
  1079.         return NULL;
  1080.     SetResFileAttrs(refNum,
  1081.                     attrs);
  1082.     {
  1083.         OSErr _err = ResError();
  1084.         if (_err != noErr) return PyMac_Error(_err);
  1085.     }
  1086.     Py_INCREF(Py_None);
  1087.     _res = Py_None;
  1088.     return _res;
  1089. }
  1090.  
  1091. static PyObject *Res_OpenRFPerm(_self, _args)
  1092.     PyObject *_self;
  1093.     PyObject *_args;
  1094. {
  1095.     PyObject *_res = NULL;
  1096.     short _rv;
  1097.     Str255 fileName;
  1098.     short vRefNum;
  1099.     SignedByte permission;
  1100.     if (!PyArg_ParseTuple(_args, "O&hb",
  1101.                           PyMac_GetStr255, fileName,
  1102.                           &vRefNum,
  1103.                           &permission))
  1104.         return NULL;
  1105.     _rv = OpenRFPerm(fileName,
  1106.                      vRefNum,
  1107.                      permission);
  1108.     {
  1109.         OSErr _err = ResError();
  1110.         if (_err != noErr) return PyMac_Error(_err);
  1111.     }
  1112.     _res = Py_BuildValue("h",
  1113.                          _rv);
  1114.     return _res;
  1115. }
  1116.  
  1117. static PyObject *Res_RGetResource(_self, _args)
  1118.     PyObject *_self;
  1119.     PyObject *_args;
  1120. {
  1121.     PyObject *_res = NULL;
  1122.     Handle _rv;
  1123.     ResType theType;
  1124.     short theID;
  1125.     if (!PyArg_ParseTuple(_args, "O&h",
  1126.                           PyMac_GetOSType, &theType,
  1127.                           &theID))
  1128.         return NULL;
  1129.     _rv = RGetResource(theType,
  1130.                        theID);
  1131.     {
  1132.         OSErr _err = ResError();
  1133.         if (_err != noErr) return PyMac_Error(_err);
  1134.     }
  1135.     _res = Py_BuildValue("O&",
  1136.                          ResObj_New, _rv);
  1137.     return _res;
  1138. }
  1139.  
  1140. static PyObject *Res_HOpenResFile(_self, _args)
  1141.     PyObject *_self;
  1142.     PyObject *_args;
  1143. {
  1144.     PyObject *_res = NULL;
  1145.     short _rv;
  1146.     short vRefNum;
  1147.     long dirID;
  1148.     Str255 fileName;
  1149.     SignedByte permission;
  1150.     if (!PyArg_ParseTuple(_args, "hlO&b",
  1151.                           &vRefNum,
  1152.                           &dirID,
  1153.                           PyMac_GetStr255, fileName,
  1154.                           &permission))
  1155.         return NULL;
  1156.     _rv = HOpenResFile(vRefNum,
  1157.                        dirID,
  1158.                        fileName,
  1159.                        permission);
  1160.     {
  1161.         OSErr _err = ResError();
  1162.         if (_err != noErr) return PyMac_Error(_err);
  1163.     }
  1164.     _res = Py_BuildValue("h",
  1165.                          _rv);
  1166.     return _res;
  1167. }
  1168.  
  1169. static PyObject *Res_HCreateResFile(_self, _args)
  1170.     PyObject *_self;
  1171.     PyObject *_args;
  1172. {
  1173.     PyObject *_res = NULL;
  1174.     short vRefNum;
  1175.     long dirID;
  1176.     Str255 fileName;
  1177.     if (!PyArg_ParseTuple(_args, "hlO&",
  1178.                           &vRefNum,
  1179.                           &dirID,
  1180.                           PyMac_GetStr255, fileName))
  1181.         return NULL;
  1182.     HCreateResFile(vRefNum,
  1183.                    dirID,
  1184.                    fileName);
  1185.     {
  1186.         OSErr _err = ResError();
  1187.         if (_err != noErr) return PyMac_Error(_err);
  1188.     }
  1189.     Py_INCREF(Py_None);
  1190.     _res = Py_None;
  1191.     return _res;
  1192. }
  1193.  
  1194. static PyObject *Res_FSpOpenResFile(_self, _args)
  1195.     PyObject *_self;
  1196.     PyObject *_args;
  1197. {
  1198.     PyObject *_res = NULL;
  1199.     short _rv;
  1200.     FSSpec spec;
  1201.     SignedByte permission;
  1202.     if (!PyArg_ParseTuple(_args, "O&b",
  1203.                           PyMac_GetFSSpec, &spec,
  1204.                           &permission))
  1205.         return NULL;
  1206.     _rv = FSpOpenResFile(&spec,
  1207.                          permission);
  1208.     {
  1209.         OSErr _err = ResError();
  1210.         if (_err != noErr) return PyMac_Error(_err);
  1211.     }
  1212.     _res = Py_BuildValue("h",
  1213.                          _rv);
  1214.     return _res;
  1215. }
  1216.  
  1217. static PyObject *Res_FSpCreateResFile(_self, _args)
  1218.     PyObject *_self;
  1219.     PyObject *_args;
  1220. {
  1221.     PyObject *_res = NULL;
  1222.     FSSpec spec;
  1223.     OSType creator;
  1224.     OSType fileType;
  1225.     ScriptCode scriptTag;
  1226.     if (!PyArg_ParseTuple(_args, "O&O&O&h",
  1227.                           PyMac_GetFSSpec, &spec,
  1228.                           PyMac_GetOSType, &creator,
  1229.                           PyMac_GetOSType, &fileType,
  1230.                           &scriptTag))
  1231.         return NULL;
  1232.     FSpCreateResFile(&spec,
  1233.                      creator,
  1234.                      fileType,
  1235.                      scriptTag);
  1236.     {
  1237.         OSErr _err = ResError();
  1238.         if (_err != noErr) return PyMac_Error(_err);
  1239.     }
  1240.     Py_INCREF(Py_None);
  1241.     _res = Py_None;
  1242.     return _res;
  1243. }
  1244.  
  1245. static PyObject *Res_Resource(_self, _args)
  1246.     PyObject *_self;
  1247.     PyObject *_args;
  1248. {
  1249.     PyObject *_res = NULL;
  1250.  
  1251.     char *buf;
  1252.     int len;
  1253.     Handle h;
  1254.  
  1255.     if (!PyArg_ParseTuple(_args, "s#", &buf, &len))
  1256.         return NULL;
  1257.     h = NewHandle(len);
  1258.     if ( h == NULL ) {
  1259.         PyErr_NoMemory();
  1260.         return NULL;
  1261.     }
  1262.     HLock(h);
  1263.     memcpy(*h, buf, len);
  1264.     HUnlock(h);
  1265.     return (PyObject *)ResObj_New(h);
  1266.  
  1267. }
  1268.  
  1269. static PyMethodDef Res_methods[] = {
  1270.     {"InitResources", (PyCFunction)Res_InitResources, 1,
  1271.      "() -> (short _rv)"},
  1272.     {"RsrcZoneInit", (PyCFunction)Res_RsrcZoneInit, 1,
  1273.      "() -> None"},
  1274.     {"CloseResFile", (PyCFunction)Res_CloseResFile, 1,
  1275.      "(short refNum) -> None"},
  1276.     {"ResError", (PyCFunction)Res_ResError, 1,
  1277.      "() -> (short _rv)"},
  1278.     {"CurResFile", (PyCFunction)Res_CurResFile, 1,
  1279.      "() -> (short _rv)"},
  1280.     {"CreateResFile", (PyCFunction)Res_CreateResFile, 1,
  1281.      "(Str255 fileName) -> None"},
  1282.     {"OpenResFile", (PyCFunction)Res_OpenResFile, 1,
  1283.      "(Str255 fileName) -> (short _rv)"},
  1284.     {"UseResFile", (PyCFunction)Res_UseResFile, 1,
  1285.      "(short refNum) -> None"},
  1286.     {"CountTypes", (PyCFunction)Res_CountTypes, 1,
  1287.      "() -> (short _rv)"},
  1288.     {"Count1Types", (PyCFunction)Res_Count1Types, 1,
  1289.      "() -> (short _rv)"},
  1290.     {"GetIndType", (PyCFunction)Res_GetIndType, 1,
  1291.      "(short index) -> (ResType theType)"},
  1292.     {"Get1IndType", (PyCFunction)Res_Get1IndType, 1,
  1293.      "(short index) -> (ResType theType)"},
  1294.     {"SetResLoad", (PyCFunction)Res_SetResLoad, 1,
  1295.      "(Boolean load) -> None"},
  1296.     {"CountResources", (PyCFunction)Res_CountResources, 1,
  1297.      "(ResType theType) -> (short _rv)"},
  1298.     {"Count1Resources", (PyCFunction)Res_Count1Resources, 1,
  1299.      "(ResType theType) -> (short _rv)"},
  1300.     {"GetIndResource", (PyCFunction)Res_GetIndResource, 1,
  1301.      "(ResType theType, short index) -> (Handle _rv)"},
  1302.     {"Get1IndResource", (PyCFunction)Res_Get1IndResource, 1,
  1303.      "(ResType theType, short index) -> (Handle _rv)"},
  1304.     {"GetResource", (PyCFunction)Res_GetResource, 1,
  1305.      "(ResType theType, short theID) -> (Handle _rv)"},
  1306.     {"Get1Resource", (PyCFunction)Res_Get1Resource, 1,
  1307.      "(ResType theType, short theID) -> (Handle _rv)"},
  1308.     {"GetNamedResource", (PyCFunction)Res_GetNamedResource, 1,
  1309.      "(ResType theType, Str255 name) -> (Handle _rv)"},
  1310.     {"Get1NamedResource", (PyCFunction)Res_Get1NamedResource, 1,
  1311.      "(ResType theType, Str255 name) -> (Handle _rv)"},
  1312.     {"UniqueID", (PyCFunction)Res_UniqueID, 1,
  1313.      "(ResType theType) -> (short _rv)"},
  1314.     {"Unique1ID", (PyCFunction)Res_Unique1ID, 1,
  1315.      "(ResType theType) -> (short _rv)"},
  1316.     {"UpdateResFile", (PyCFunction)Res_UpdateResFile, 1,
  1317.      "(short refNum) -> None"},
  1318.     {"SetResPurge", (PyCFunction)Res_SetResPurge, 1,
  1319.      "(Boolean install) -> None"},
  1320.     {"GetResFileAttrs", (PyCFunction)Res_GetResFileAttrs, 1,
  1321.      "(short refNum) -> (short _rv)"},
  1322.     {"SetResFileAttrs", (PyCFunction)Res_SetResFileAttrs, 1,
  1323.      "(short refNum, short attrs) -> None"},
  1324.     {"OpenRFPerm", (PyCFunction)Res_OpenRFPerm, 1,
  1325.      "(Str255 fileName, short vRefNum, SignedByte permission) -> (short _rv)"},
  1326.     {"RGetResource", (PyCFunction)Res_RGetResource, 1,
  1327.      "(ResType theType, short theID) -> (Handle _rv)"},
  1328.     {"HOpenResFile", (PyCFunction)Res_HOpenResFile, 1,
  1329.      "(short vRefNum, long dirID, Str255 fileName, SignedByte permission) -> (short _rv)"},
  1330.     {"HCreateResFile", (PyCFunction)Res_HCreateResFile, 1,
  1331.      "(short vRefNum, long dirID, Str255 fileName) -> None"},
  1332.     {"FSpOpenResFile", (PyCFunction)Res_FSpOpenResFile, 1,
  1333.      "(FSSpec spec, SignedByte permission) -> (short _rv)"},
  1334.     {"FSpCreateResFile", (PyCFunction)Res_FSpCreateResFile, 1,
  1335.      "(FSSpec spec, OSType creator, OSType fileType, ScriptCode scriptTag) -> None"},
  1336.     {"Resource", (PyCFunction)Res_Resource, 1,
  1337.      "Convert a string to a resource object.\n\nThe created resource object is actually just a handle.\nApply AddResource() to write it to a resource file.\n"},
  1338.     {NULL, NULL, 0}
  1339. };
  1340.  
  1341.  
  1342.  
  1343.  
  1344. /* Alternative version of ResObj_New, which returns None for null argument */
  1345. PyObject *OptResObj_New(itself)
  1346.     Handle itself;
  1347. {
  1348.     if (itself == NULL) {
  1349.         Py_INCREF(Py_None);
  1350.         return Py_None;
  1351.     }
  1352.     return ResObj_New(itself);
  1353. }
  1354.  
  1355. OptResObj_Convert(v, p_itself)
  1356.     PyObject *v;
  1357.     Handle *p_itself;
  1358. {
  1359.     if ( v == Py_None ) {
  1360.         *p_itself = NULL;
  1361.         return 1;
  1362.     }
  1363.     if (!ResObj_Check(v))
  1364.     {
  1365.         PyErr_SetString(PyExc_TypeError, "Resource required");
  1366.         return 0;
  1367.     }
  1368.     *p_itself = ((ResourceObject *)v)->ob_itself;
  1369.     return 1;
  1370. }
  1371.  
  1372.  
  1373.  
  1374. void initRes()
  1375. {
  1376.     PyObject *m;
  1377.     PyObject *d;
  1378.  
  1379.  
  1380.  
  1381.  
  1382.  
  1383.     m = Py_InitModule("Res", Res_methods);
  1384.     d = PyModule_GetDict(m);
  1385.     Res_Error = PyMac_GetOSErrException();
  1386.     if (Res_Error == NULL ||
  1387.         PyDict_SetItemString(d, "Error", Res_Error) != 0)
  1388.         Py_FatalError("can't initialize Res.Error");
  1389. }
  1390.  
  1391. /* ========================= End module Res ========================= */
  1392.  
  1393.